import { getDetailByTargetType } from "@/api/uap";

class DictCache {
  constructor(_options = {}) {
    // 必需依赖注入
    // if (!options.store) throw new Error("Vuex store is required");
    // if (!options.request) throw new Error("API request method is required");
    //
    // // 配置参数（带默认值）
    // this.store = options.store; //必传
    // this.request = options.request; //api 方法 必传
    // this.namespace = options.namespace || "dict"; //VueX 引入的ModeName 必传
    // this.storageName = options.storageName || "vue-dict-cache";
    // this.storeName = options.storeName || "dict_cache";
    //
    // // 初始化缓存存储
    // this.dictStore = localforage.createInstance({
    //   name: this.storageName,
    //   storeName: this.storeName,
    //   description: "Vue字典数据缓存",
    // });
    //
    // // 常量定义
    // this.MAX_VERSION_KEY = "max_dict_version";
    // this.pendingRequests = new Map(); // 请求合并池
  }

  /**
   * 初始化字典系统
   * @returns {Promise<number>} 当前字典版本号
   */
  // async init() {
  //   // 初始化最大版本号
  //   const version = await this.getMaxVersion();
  //   if (version === null || version === undefined) {
  //     await this.updateMaxVersion(0);
  //     return 0;
  //   }
  //   return version;
  // }
  async getDictData(codeType: string) {
    // 1. 从Vuex内存获取
    // const vuexData = this.getFromVuex(codeType);
    // if (vuexData) {
    //   return { data: vuexData, source: "memory" };
    // }

    // 2. 从IndexedDB获取
    // const indexedDBData = await this.getFromIndexedDB(codeType);
    // if (indexedDBData) {
    //   this.saveToVuex(codeType, indexedDBData.data, indexedDBData.version);
    //   return { data: indexedDBData.data, source: "indexedDB" };
    // }

    // 3. 从API获取（含请求合并）
    // return this.fetchFromApi(codeType);
    return getDetailByTargetType({ code: codeType });
  }

  /* ========== 缓存层级方法 ========== */

  // getFromVuex(codeType) {
  //   const dict = this.store.state[this.namespace].cache[codeType];
  //   // const dict = this.store.state[this.namespace]?.cache?.[codeType];
  //   if (dict && dict.data) {
  //     return dict.data;
  //   }
  //   return null;
  // }
  //
  // saveToVuex(codeType, data, version) {
  //   this.store.commit(`${this.namespace}/setDictData`, {
  //     codeType,
  //     data: { data, version },
  //   });
  // }
  //
  // async getFromIndexedDB(codeType) {
  //   try {
  //     const data = await this.dictStore.getItem(codeType);
  //     if (!data) return null;
  //
  //     // 检查版本有效性
  //     const maxVersion = await this.getMaxVersion();
  //     if (data.version < maxVersion) {
  //       console.warn(
  //         `[DictCache] 字典 ${codeType} 版本过期 (${data.version} < ${maxVersion})`,
  //       );
  //       return null;
  //     }
  //     return data;
  //   } catch (error) {
  //     console.error(`[DictCache] IndexedDB读取失败 (${codeType}):`, error);
  //     return null;
  //   }
  // }
  //
  // async saveToIndexedDB(codeType, data, version) {
  //   try {
  //     await this.dictStore.setItem(codeType, { data, version });
  //   } catch (error) {
  //     console.error(`[DictCache] IndexedDB保存失败 (${codeType}):`, error);
  //   }
  // }
  //
  // /* ========== API请求相关 ========== */
  //
  // async fetchFromApi(codeType) {
  //   // 请求合并：已有相同请求直接返回Promise
  //   if (this.pendingRequests.has(codeType)) {
  //     console.log(`已有 ${codeType} 的请求正在进行，等待结果...`);
  //     return this.pendingRequests.get(codeType);
  //   }
  //
  //   // 创建新请求
  //   const requestPromise = new Promise(async (resolve, reject) => {
  //     try {
  //       const response = await this.request({ code: codeType });
  //
  //       if (!response || !response.data) {
  //         console.log(`API返回数据格式错误: ${JSON.stringify(response)}`);
  //         return null;
  //       }
  //
  //       const { items, version } = response.data;
  //
  //       // 更新各级缓存
  //       await this.saveToIndexedDB(codeType, items, version);
  //       this.saveToVuex(codeType, items, version);
  //       await this.updateMaxVersion(version);
  //
  //       resolve({ data: items, source: "api" });
  //     } catch (error) {
  //       console.log(`[DictCache] API请求失败 (${codeType}):`, error);
  //       reject(error);
  //     } finally {
  //       this.pendingRequests.delete(codeType);
  //     }
  //   });
  //
  //   this.pendingRequests.set(codeType, requestPromise);
  //   return requestPromise;
  // }
  //
  // /* ========== 版本控制 ========== */
  //
  // async getMaxVersion() {
  //   // Vuex内存优先
  //   console.log("获取最大版本号");
  //   if (
  //     this.store.state[this.namespace] &&
  //     this.store.state[this.namespace].maxVersion !== null
  //   ) {
  //     console.log(
  //       this.store.state[this.namespace].maxVersion,
  //       "vueX中最大版本号",
  //     );
  //     return this.store.state[this.namespace].maxVersion;
  //   }
  //
  //   // IndexedDB持久化存储
  //   try {
  //     const version = (await localforage.getItem(this.MAX_VERSION_KEY)) || 0;
  //     console.log(version, "indexedDB中最大版本号");
  //     this.store.commit(`${this.namespace}/setMaxVersion`, version);
  //     return version;
  //   } catch (error) {
  //     console.error("[DictCache] 获取版本号失败:", error);
  //     return 0;
  //   }
  // }
  //
  // async updateMaxVersion(newVersion) {
  //   try {
  //     const currentVersion = await this.getMaxVersion();
  //     if (newVersion > currentVersion) {
  //       await localforage.setItem(this.MAX_VERSION_KEY, newVersion);
  //       this.store.commit(`${this.namespace}/setMaxVersion`, newVersion);
  //     }
  //   } catch (error) {
  //     console.error("[DictCache] 更新版本号失败:", error);
  //   }
  // }
  //
  // /* ========== 缓存清理 ========== */
  //
  // async clearDictCache(codeType) {
  //   // 清理Vuex
  //   this.store.commit(`${this.namespace}/removeDictData`, codeType);
  //
  //   // 清理IndexedDB
  //   try {
  //     await this.dictStore.removeItem(codeType);
  //   } catch (error) {
  //     console.error(`[DictCache] 清理字典缓存失败 (${codeType}):`, error);
  //   }
  // }
  //
  // async clearAllCache() {
  //   // 清理Vuex
  //   this.store.commit(`${this.namespace}/clearAllDictData`);
  //
  //   // 清理IndexedDB
  //   try {
  //     await this.dictStore.clear();
  //     await localforage.setItem(this.MAX_VERSION_KEY, 0);
  //     this.store.commit(`${this.namespace}/setMaxVersion`, 0);
  //   } catch (error) {
  //     console.error("[DictCache] 清理全局缓存失败:", error);
  //   }
  // }
}

export default new DictCache();
